
// import chisel3._
// import chiseltest._
// import org.scalatest.{Matchers, FlatSpec}
// import scala.util.Random

// import comlib.chisel._

// class ComparatorSpec extends FlatSpec with ChiselScalatestTester with Matchers {

//     behavior of "Comparator"

//     val rnd = new Random

//     it should "support >;>=;<;<=;===;=/= operator" in {
//         test( new Module {
//             val io = IO(new Bundle{
//                 val a_key = Input(UInt(4.W))
//                 val b_key = Input(UInt(4.W))
//                 val large = Output(Bool())
//                 val leq = Output(Bool())
//                 val small = Output(Bool())
//                 val seq = Output(Bool())
//                 val eq = Output(Bool())
//                 val neq = Output(Bool())
//             })
            
//             val cmp1 = Comparator( true.B, io.a_key, 0.U )
//             val cmp2 = Comparator( true.B, io.b_key, 0.U )

//             io.large := cmp1 > cmp2
//             io.leq := cmp1 >= cmp2
//             io.small := cmp1 < cmp2
//             io.seq := cmp1 <= cmp2
//             io.eq := cmp1 === cmp2
//             io.neq := cmp1 =/= cmp2

//         } ){ dut =>
            
//             for( slot <- 0 until 100 ){
//                 val a_key = rnd.nextInt(16)
//                 val b_key = rnd.nextInt(16)
//                 dut.io.a_key.poke( a_key.U )
//                 dut.io.b_key.poke( b_key.U )
//                 dut.io.large.expect( (a_key>b_key).B )
//                 dut.io.leq.expect( (a_key>=b_key).B )
//                 dut.io.small.expect( (a_key<b_key).B )
//                 dut.io.seq.expect( (a_key<=b_key).B )
//                 dut.io.eq.expect( (a_key==b_key).B )
//                 dut.io.neq.expect( (a_key!=b_key).B )
//             }

//         }
//     }

//     it should "support max operator and Bundle<=>UInt tranlation" in {
//         test( new Module {
//             val io = IO(new Bundle{
//                 val a = Input(UInt(25.W))

//                 // val b = Flipped(new ComparatorWithValid(8, Wire(UInt(16.W))))   // Reference _T is not fully initialized.
//                 val b = Flipped(chiselTypeOf(Comparator(false.B, 0.U(8.W), 0.U(16.W))))

//                 val b_vld = Input(Bool())
//                 val b_key = Input(UInt(8.W))
//                 val b_val = Input(UInt(16.W))

//                 val out_vld = Output(Bool())
//                 val out_key = Output(UInt())
//                 val out_val = Output(UInt())

//                 val out_uint = Output(UInt())
//             })
            
//             val cmp1 = io.a.asTypeOf(Comparator(false.B, 0.U(8.W), 0.U(16.W)))
//             // val cmp1 = io.a.asTypeOf(ComparatorWithValid(8, UInt(16.W)))  // Reference _T is not fully initialized.
//             val cmp2 = Comparator( io.b_vld, io.b_key, io.b_val )

//             val ret = cmp1.cmp(_>=_)(cmp2)

//             io.out_vld := ret.vld
//             io.out_key := ret.key
//             io.out_val := ret.data

//             io.out_uint := ret.asTypeOf(UInt())

//         } ){ dut =>

//             for( i <- 0 until 100 ){
//                 val a_vld = rnd.nextInt(1) > 0
//                 val a_key = rnd.nextInt(16)
//                 val a_val = rnd.nextInt(10000)
//                 val b_vld = rnd.nextInt(1) > 0
//                 val b_key = rnd.nextInt(16)
//                 val b_val = rnd.nextInt(10000)

//                 val op_a = (a_key<<17) + (a_val << 1) + (if(a_vld) 1 else 0)
//                 dut.io.a.poke( op_a.U )

//                 dut.io.b_vld.poke( b_vld.B )            
//                 dut.io.b_key.poke( b_key.U )
//                 dut.io.b_val.poke( b_val.U )

//                 dut.io.b.vld.poke( b_vld.B )
//                 dut.io.b.key.poke( b_key.U )
//                 // dut.io.b.data.poke( b_val.U )

//                 val o_vld = a_vld | b_vld
//                 val is_a = (a_vld && a_key >= b_key) | !b_vld

//                 val o_key = if( is_a ) a_key else b_key
//                 val o_val = if( is_a ) a_val else b_val

//                 dut.io.out_vld.expect( o_vld.B )
//                 dut.io.out_key.expect( o_key.U, s"a_key=${a_key} b_key=${b_key} and loop=${i}" )
//                 dut.io.out_val.expect( o_val.U )

//                 dut.io.out_uint.expect( ((o_key<<17) + (o_val << 1) + (if(o_vld) 1 else 0)).U, s"o_vld=${o_vld} o_key=${o_key} o_val=${o_val}" )

//             }
//         }
//     }

// }